home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / madtrb1.arc / DISPLAY.INC next >
Text File  |  1986-02-27  |  21KB  |  506 lines
  1. { DISPLAY.INC }
  2.  
  3. { *************************************************************************** }
  4. { *                                                                         * }
  5. { *                TURBO SCREEN INPUT PRE-PROCESSOR TOOLKIT                 * }
  6. { *                                                                         * }
  7. { *             DISPLAY SCROLLING INPUT SUBPROGRAM INCLUDE FILE             * }
  8. { *                                                                         * }
  9. { *                             Version  1.07                               * }
  10. { *                                                                         * }
  11. { *                                                                         * }
  12. { *   This include file provides a visual representation of the scrolling   * }
  13. { *   input data as the user enters it.  Note that this include file is     * }
  14. { *   specific to the example application of the input pre-processor,       * }
  15. { *   although you may want to write a similar routine that perhaps         * }
  16. { *   displays a graph, bar chart, etc. representing the user entered input * }
  17. { *   data.                                                                 * }
  18. { *                                                                         * }
  19. { *************************************************************************** }
  20.  
  21.  
  22.  
  23. Const
  24.   TOP_EDGE_OF_DISPLAY_WINDOW=2;        { top physical screen row of the display window }
  25.   BOTTOM_EDGE_OF_DISPLAY_WINDOW=9;     { bottom physical screen row of the display window }
  26.   LEFT_EDGE_OF_DISPLAY_WINDOW=3;       { left physical screen column of the display window }
  27.   RIGHT_EDGE_OF_DISPLAY_WINDOW=78;     { right physical screen column of the display window }
  28.  
  29.  
  30.  
  31. Procedure DrawSimpleBeam;
  32.  
  33. { This procedure is specific to the example application of the input
  34.   pre-processor.  This procedure draws a representation of a beam onto the
  35.   scrolling input pages. }
  36.  
  37. Var
  38.   ScreenCol:Integer;                   { a screen column index counter }
  39.  
  40. Begin   { DrawSimpleBeam }
  41.   Window(LEFT_EDGE_OF_DISPLAY_WINDOW,  { define a portion of the screen as the active window }
  42.          TOP_EDGE_OF_DISPLAY_WINDOW,
  43.          RIGHT_EDGE_OF_DISPLAY_WINDOW,
  44.          BOTTOM_EDGE_OF_DISPLAY_WINDOW);
  45.   TextColor(ForegroundColor);
  46.   TextBackground(BackgroundColor);
  47.   GotoXY(17,4);                        { draw beam }
  48.     For ScreenCol:=1 To 40 Do
  49.       Write(Chr(22));
  50.   GotoXY(17,5);                        { draw left beam support }
  51.     Write(Chr(94));
  52.   GotoXY(56,5);                        { draw right beam support }
  53.     Write(Chr(94));
  54.   GotoXY(58,6);
  55.     Write('LOAD');
  56.   GotoXY(58,7);
  57.     Write('TYPE:');
  58.   If (S_I_Page=1) Or (S_I_Page=3) Then
  59.     Begin
  60.       GotoXY(58,8);
  61.       Write('WIDTH:');
  62.     End; { If Page }
  63.   GotoXY(17,6);                        { draw dimension line }
  64.     Write(Chr(179));
  65.   GotoXY(56,6);
  66.     Write(Chr(179));
  67.   GotoXY(17,7);
  68.     Write(Chr(179));
  69.   GotoXY(56,7);
  70.     Write(Chr(179));
  71.   GotoXY(17,8);
  72.     Write(Chr(195));
  73.   GotoXY(56,8);
  74.     Write(Chr(180));
  75.   GotoXY(18,8);
  76.     For ScreenCol:=1 To 38 Do
  77.       Write(Chr(196));
  78. End;    { DrawSimpleBeam }
  79.  
  80.  
  81.  
  82. Procedure DisplayBeamLength;
  83.  
  84. { This procedure is specific to the example application of the input
  85.   pre-processor.  This procedure displays the inputed beam length under the
  86.   displayed beam. }
  87.  
  88. Begin   { DisplayBeamLength }
  89.   Window(LEFT_EDGE_OF_DISPLAY_WINDOW,  { define a portion of the screen as the active window }
  90.          TOP_EDGE_OF_DISPLAY_WINDOW,
  91.          RIGHT_EDGE_OF_DISPLAY_WINDOW,
  92.          BOTTOM_EDGE_OF_DISPLAY_WINDOW);
  93.   TextColor(ForegroundColor);
  94.   TextBackground(BackgroundColor);
  95.   GotoXY(34-((Length(G_I_Data[13,1]^)) Div 2),8);
  96.   Write(' ',G_I_Data[13,1]^,' ft. ');
  97. End;    { DisplayBeamLength }
  98.  
  99.  
  100.  
  101. Procedure DisplayBeamLoadModule;{(    CurrentInputCol,
  102.                                       CurrentInputRow:Integer);}
  103.  
  104. { *************************************************************************** }
  105. { *                                                                         * }
  106. { *                       BEAM LOADING DISPLAY MODULE                       * }
  107. { *                                                                         * }
  108. { *    This module takes care of the display of individual beam loadings.   * }
  109. { *    It first removes the previous loading from the model beam and then   * }
  110. { *    displays the current beam loading under investigation.               * }
  111. { *                                                                         * }
  112. { *    Note that this module is specific to the example application of the  * }
  113. { *    input pre-processor.                                                 * }
  114. { *                                                                         * }
  115. { *************************************************************************** }
  116.  
  117. Var { Modular Variables, i.e. global only to this module }
  118.  
  119.   X_Entry:Integer;                     { variable used to store converted string load data entries }
  120.   X1_Entry:Integer;                    { variable used to store converted string load data entries }
  121.   X2_Entry:Integer;                    { variable used to store converted string load data entries }
  122.  
  123.   X_Position:Integer;                  { variable indicate screen positions for showing limits of applied load }
  124.   X1_Position:Integer;                 { variable indicate screen positions for showing limits of applied load }
  125.   X2_Position:Integer;                 { variable indicate screen positions for showing limits of applied load }
  126.  
  127.  
  128.  
  129.   Procedure InitBeamLoadDisplay;
  130.  
  131.   { This procedure initializes the beam loading module.  It determines values
  132.     for beam length and load dimension lines. }
  133.  
  134.   Var
  135.     ErrorCode:Integer;                 { variable used in the return of an error code during string conversion to integer }
  136.  
  137.   Begin   { InitBeamLoadDisplay }
  138.     { Convert string data into data of type real }
  139.     Val(G_I_Data[13,1]^,BeamLength,ErrorCode);
  140.     Val(S_I_Data[2,CurrentInputRow,S_I_Page]^,X_Entry,ErrorCode);
  141.     X1_Entry:=X_Entry;
  142.     Val(S_I_Data[4,CurrentInputRow,S_I_Page]^,X2_Entry,ErrorCode);
  143.     { Define screen position variables }
  144.     X_Position:=Trunc(X_Entry*39/BeamLength);
  145.     X1_Position:=X_Position;
  146.     X2_Position:=Trunc(X2_Entry*39/BeamLength);
  147.   End;    { InitBeamLoadDisplay }
  148.  
  149.  
  150.  
  151.   Procedure RemoveBeamLoading;
  152.  
  153.   { This procedure removes the graphical loading on the displayed beam. }
  154.  
  155.   Begin   { RemoveBeamLoading }
  156.     TextColor(ForegroundColor);
  157.     TextBackground(BackgroundColor);
  158.     Window(3,2,76,4);                  { remove beam loading }
  159.       ClrScr;
  160.     Window(20,6,57,8);                 { remove dimension strings }
  161.       ClrScr;
  162.     Window(3,7,18,8);                  { remove X1 (or X) and X2 identifier }
  163.       ClrScr;
  164.     Window(66,8,78,9);                 { remove load type and width identifiers }
  165.       ClrScr;
  166.     Window(LEFT_EDGE_OF_DISPLAY_WINDOW, { define a portion of the screen as the active window }
  167.            TOP_EDGE_OF_DISPLAY_WINDOW,
  168.            RIGHT_EDGE_OF_DISPLAY_WINDOW,
  169.            BOTTOM_EDGE_OF_DISPLAY_WINDOW);
  170.     GotoXY(17,6);                      { remove ends of dimension strings from beam length leaders }
  171.       Write(Chr(179));
  172.     GotoXY(56,6);
  173.       Write(Chr(179));
  174.     GotoXY(17,7);
  175.       Write(Chr(179));
  176.     GotoXY(56,7);
  177.       Write(Chr(179));
  178.   End;    { RemoveBeamLoading }
  179.  
  180.  
  181.  
  182.   Procedure ShowUniformLoading;
  183.  
  184.   { This procedure shows the uniform load acting upon the beam. }
  185.  
  186.   Var
  187.     ScreenCol:Integer;                 { a screen column index counter }
  188.  
  189.   Begin   { ShowUniformLoading }
  190.     If(S_I_Data[2,CurrentInputRow,S_I_Page]^<>'') And (S_I_Data[4,CurrentInputRow,S_I_Page]^<>'') Then
  191.       Begin                            { enough data to display loading }
  192.         GotoXY(X1_Position+17,3);      { show uniform load above beam }
  193.         For ScreenCol:=X1_Position To X2_Position Do
  194.           Write(Chr(219));
  195.         If S_I_Data[3,CurrentInputRow,S_I_Page]^<>'' Then
  196.           Begin
  197.             GotoXY(((X1_Position+X2_Position) Div 2)+17-(Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)+4) Div 2,2);
  198.             TextColor(HighlightColor);
  199.             Write(S_I_Data[3,CurrentInputRow,S_I_Page]^,' psf');
  200.             TextColor(ForegroundColor);
  201.           End; { If S_I_Data }
  202.       End; { If S_I_Data }
  203.   End;    { ShowUniformLoading }
  204.  
  205.  
  206.  
  207.   Procedure ShowPointLoading;
  208.  
  209.   { This procedure shows the point load acting upon the beam. }
  210.  
  211.   Begin   { ShowPointLoading }
  212.     If(S_I_Data[2,CurrentInputRow,S_I_Page]^<>'') And (S_I_Data[3,CurrentInputRow,S_I_Page]^<>'') Then
  213.       Begin                            { enough data to display loading }
  214.         If Copy(S_I_Data[3,CurrentInputRow,S_I_Page]^,1,1)='-' Then
  215.           Begin                        { show upward acting point load (negative load) above beam }
  216.             GotoXY(X_Position+17,3);
  217.               Write(Chr(24));
  218.             GotoXY(X_Position+17-(Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)-1+5) Div 2,2);
  219.             TextColor(HighlightColor);
  220.             Write(Copy(S_I_Data[3,CurrentInputRow,S_I_Page]^,2,Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)-1));
  221.             Write(' kips');
  222.             TextColor(ForegroundColor);
  223.           End { If Copy(S_I_Data }
  224.         Else
  225.           Begin                        { show downward acting point load (positive load) above beam }
  226.             GotoXY(X_Position+17,3);
  227.               Write(Chr(25));
  228.             GotoXY(X_Position+17-(Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)+5) Div 2,2);
  229.             TextColor(HighlightColor);
  230.             Write(S_I_Data[3,CurrentInputRow,S_I_Page]^,' kips');
  231.             TextColor(ForegroundColor);
  232.           End; { Else }
  233.       End; { If S_I_Data }
  234.   End;    { ShowPointLoading }
  235.  
  236.  
  237.  
  238.   Procedure ShowPrismaticLoading;
  239.  
  240.   { This procedure shows the prismatic load acting upon the beam. }
  241.  
  242.   Var
  243.     X1_LoadEntry:Real;                 { variable used to store converted string load data }
  244.     X2_LoadEntry:Real;                 { variable used to store converted string load data }
  245.     ErrorCode:Integer;                 { variable used in the return of an error code during string conversion to integer }
  246.     ScreenCol:Integer;                 { a screen column index counter }
  247.  
  248.   Begin   { ShowPrismaticLoading }
  249.     If(S_I_Data[2,CurrentInputRow,S_I_Page]^<>'') And (S_I_Data[4,CurrentInputRow,S_I_Page]^<>'') And
  250.       (S_I_Data[3,CurrentInputRow,S_I_Page]^<>'') And (S_I_Data[5,CurrentInputRow,S_I_Page]^<>'') Then
  251.       Begin                            { enough data to display loading }
  252.         GotoXY(X1_Position+17,3);
  253.         For ScreenCol:=X1_Position To X2_Position Do
  254.           Write(Chr(220));
  255.         Val(S_I_Data[3,CurrentInputRow,S_I_Page]^,X1_LoadEntry,ErrorCode);
  256.         Val(S_I_Data[5,CurrentInputRow,S_I_Page]^,X2_LoadEntry,ErrorCode);
  257.         If (X1_LoadEntry)<(X2_LoadEntry) Then
  258.           Begin                        { prismatic load slopes to the left }
  259.             For ScreenCol:=Trunc(((X1_Position)*0.75)+((X2_Position)/4)) To X2_Position Do
  260.               Begin
  261.                 GotoXY(ScreenCol+17,3);
  262.                 Write(Chr(219));
  263.               End; { For ScreenCol }
  264.             For ScreenCol:=(X1_Position+X2_Position) Div 2 To X2_Position Do
  265.               Begin
  266.                 GotoXY(ScreenCol+17,2);
  267.                 Write(Chr(220));
  268.               End; { For ScreenCol }
  269.             For ScreenCol:=Trunc(((X1_Position)/4)+((X2_Position)/1.333)) To X2_Position Do
  270.               Begin
  271.                 GotoXY(ScreenCol+17,2);
  272.                 Write(Chr(219));
  273.               End; { For ScreenCol }
  274.           TextColor(HighlightColor);
  275.           GotoXY(X1_Position-Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)-3+17,2);
  276.             Write(S_I_Data[3,CurrentInputRow,S_I_Page]^,' psf');
  277.           GotoXY(X2_Position+17,1);
  278.             Write(S_I_Data[5,CurrentInputRow,S_I_Page]^,' psf');
  279.           TextColor(ForegroundColor);
  280.           End { If X1_LoadEntry }
  281.         Else
  282.           Begin                        { prismatic load slopes to the right }
  283.             For ScreenCol:=X1_Position To Trunc(((X1_Position)/4)+((X2_Position)/1.333)) Do
  284.               Begin
  285.                 GotoXY(ScreenCol+17,3);
  286.                 Write(Chr(219));
  287.               End; { For ScreenCol }
  288.             For ScreenCol:=X1_Position To (X1_Position+X2_Position) Div 2 Do
  289.               Begin
  290.                 GotoXY(ScreenCol+17,2);
  291.                 Write(Chr(220));
  292.               End; { For ScreenCol }
  293.             For ScreenCol:=X1_Position To Trunc(((X1_Position)/1.333)+((X2_Position)/4)) Do
  294.               Begin
  295.                 GotoXY(ScreenCol+17,2);
  296.                 Write(Chr(219));
  297.               End; { For ScreenCol }
  298.             TextColor(HighlightColor);
  299.             GotoXY(X1_Position-Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)-3+17,1);
  300.               Write(S_I_Data[3,CurrentInputRow,S_I_Page]^,' psf');
  301.             GotoXY(X2_Position+17,2);
  302.               Write(S_I_Data[5,CurrentInputRow,S_I_Page]^,' psf');
  303.             TextColor(ForegroundColor)
  304.           End; { Else }
  305.       End; { If S_I_Data }
  306.   End;    { ShowPrismaticLoading }
  307.  
  308.  
  309.  
  310.   Procedure ShowAppliedMoment;
  311.  
  312.   { This Procedure shows the applied moment acting upon the beam. }
  313.  
  314.   Begin   { ShowAppliedMoment }
  315.     If (S_I_Data[2,CurrentInputRow,S_I_Page]^<>'') And (S_I_Data[3,CurrentInputRow,S_I_Page]^<>'') Then
  316.       Begin                            { enough data to display loading }
  317.         If Copy(S_I_Data[3,CurrentInputRow,S_I_Page]^,1,1)='-' Then
  318.           Begin                        { draw negative couple (counterclockwise couple) }
  319.             GotoXY(X_Position-1+17,2);
  320.               Write(Chr(17),Chr(191));
  321.             GotoXY(X_Position+17,3);
  322.               Write(Chr(192),Chr(16));
  323.             TextColor(HighlightColor);
  324.             GotoXY(X_Position+17+2,2);
  325.             Write(Copy(S_I_Data[3,CurrentInputRow,S_I_Page]^,2,Length(S_I_Data[3,CurrentInputRow,S_I_Page]^)-1));
  326.             Write(' ft-kips');
  327.             TextColor(ForegroundColor);
  328.           End { If Copy(S_I_Data }
  329.         Else
  330.           Begin                        { draw positive couple (clockwise couple) }
  331.             GotoXY(X_Position+17,2);
  332.               Write(Chr(218),Chr(16));
  333.             GotoXY(X_Position-1+17,3);
  334.               Write(Chr(17),Chr(217));
  335.             GotoXY(X_Position+17+2,2);
  336.             TextColor(HighlightColor);
  337.             Write(S_I_Data[3,CurrentInputRow,S_I_Page]^,' ft-kips');
  338.             TextColor(ForegroundColor);
  339.           End; { Else }
  340.       End; { If S_I_Data }
  341.   End;    { ShowAppliedMoment }
  342.  
  343.  
  344.  
  345.   Procedure Show_X_DimensionLine;
  346.  
  347.   { This procedure shows the X dimension line to indicate the point of load
  348.     application. }
  349.  
  350.   Var
  351.     ScreenCol:Integer;                 { a screen column index counter }
  352.  
  353.   Begin   { Show_X_DimensionLine }
  354.     If S_I_Data[2,CurrentInputRow,S_I_Page]^<>'' Then
  355.       Begin
  356.         If X_Position<>0 Then
  357.           Begin
  358.             GotoXY(17,6);
  359.               Write(Chr(195));
  360.             For ScreenCol:=18 To X_Position+17-1 Do
  361.               Write(Chr(196));
  362.             Write(Chr(180));
  363.             If X_Position+17<>56 Then
  364.               Begin
  365.                 GotoXY(X_Position+17,5);
  366.                   Write(Chr(179));
  367.               End; { If X_Position+17 }
  368.           End; { If X_Position }
  369.         GotoXY(16-7-Length(S_I_Data[2,CurrentInputRow,S_I_Page]^),6);
  370.         TextColor(HighlightColor);
  371.         Write('X= ',S_I_Data[2,CurrentInputRow,S_I_Page]^,' ft.');
  372.         TextColor(ForegroundColor);
  373.       End; { If S_I_Data }
  374.   End;    { Show_X_DimensionLine }
  375.  
  376.  
  377.  
  378.   Procedure Show_X1_X2_DimensionLine;
  379.  
  380.   { This procedure shows the X1 & X2 dimension lines to indicate the limits of
  381.     the load application. }
  382.  
  383.   Var
  384.     MaxLength:Integer;                 { variable used to store the length of the larger of the two strings; X1 and X2 }
  385.     ScreenCol:Integer;                 { a screen column index counter }
  386.  
  387.   Begin   { Show_X1_X2_DimensionLine }
  388.     If Length(S_I_Data[2,CurrentInputRow,S_I_Page]^)>Length(S_I_Data[4,CurrentInputRow,S_I_Page]^) Then
  389.       MaxLength:=Length(S_I_Data[2,CurrentInputRow,S_I_Page]^)
  390.     Else
  391.       MaxLength:=Length(S_I_Data[4,CurrentInputRow,S_I_Page]^);
  392.     If S_I_Data[2,CurrentInputRow,S_I_Page]^<>'' Then   { Show X1 dimension }
  393.       Begin
  394.         If X1_Position<>0 Then
  395.           Begin
  396.             GotoXY(17,6);
  397.               Write(Chr(195));
  398.             For ScreenCol:=18 To X1_Position+17-1 Do
  399.               Write(Chr(196));
  400.             Write(Chr(180));
  401.             If X1_Position+17<>56 Then
  402.               Begin
  403.                 GotoXY(X1_Position+17,5);
  404.                   Write(Chr(179));
  405.               End; { If X1_Position+17 }
  406.           End; { If X1_Position }
  407.         GotoXY(16-8-MaxLength,6);
  408.         TextColor(HighlightColor);
  409.         Write('X1= ',S_I_Data[2,CurrentInputRow,S_I_Page]^,' ft.');
  410.         TextColor(ForegroundColor);
  411.       End; { If S_I_Data }
  412.     If S_I_Data[4,CurrentInputRow,S_I_Page]^<>'' Then   { Show X2 dimension }
  413.       Begin
  414.         If X2_Position<>0 Then
  415.           Begin
  416.             GotoXY(17,7);
  417.               Write(Chr(195));
  418.             For ScreenCol:=18 To X2_Position+17-1 Do
  419.               Write(Chr(196));
  420.             Write(Chr(180));
  421.             If (X2_Position+17<>56) And (X2_Position<>X1_Position) Then
  422.               Begin
  423.                 GotoXY(X2_Position+17,5);
  424.                   Write(Chr(179));
  425.                 GotoXY(X2_Position+17,6);
  426.                   Write(Chr(179));
  427.               End; { If X2_Position+17 }
  428.           End; { If X2_Position }
  429.         GotoXY(16-8-MaxLength,7);
  430.         TextColor(HighlightColor);
  431.         Write('X2= ',S_I_Data[4,CurrentInputRow,S_I_Page]^,' ft.');
  432.         TextColor(ForegroundColor);
  433.       End; { If S_I_Data }
  434.   End;    { Show_X1_X2_DimensionLine }
  435.  
  436.  
  437.  
  438.   Procedure ShowLoadTypeIdentifier;
  439.  
  440.   { This procedure identifies the load type currently acting upon the beam. }
  441.  
  442.   Begin   { ShowLoadTypeIdentifier }
  443.     GotoXY(65,7);
  444.     TextColor(HighlightColor);
  445.     If S_I_Data[1,CurrentInputRow,S_I_Page]^<>'' Then
  446.       Write(S_I_Data[1,CurrentInputRow,S_I_Page]^);
  447.     TextColor(ForegroundColor);
  448.   End;    { ShowLoadTypeIdentifier }
  449.  
  450.  
  451.  
  452.   Procedure ShowLoadWidthIdentifier;
  453.  
  454.   { This procedure identifies the load width currently acting upon the beam. }
  455.  
  456.   Begin   { ShowLoadWidthIdentifier }
  457.     GotoXY(65,8);
  458.     TextColor(HighlightColor);
  459.     Case S_I_Page Of
  460.       1 : If S_I_Data[5,CurrentInputRow,S_I_Page]^<>'' Then
  461.             Write(S_I_Data[5,CurrentInputRow,S_I_Page]^,' ft.');
  462.       3 : If S_I_Data[6,CurrentInputRow,S_I_Page]^<>'' Then
  463.             Write(S_I_Data[6,CurrentInputRow,S_I_Page]^,' ft.');
  464.     End; { Case S_I_Page }
  465.     TextColor(ForegroundColor);
  466.   End;    { ShowLoadWidthIdentifier }
  467.  
  468.  
  469.  
  470.   Procedure ShowBeamLoading;
  471.  
  472.   { This procedure controls the specific screen procedures that are called
  473.     for specific load types. }
  474.  
  475.   Begin   { ShowBeamLoading }
  476.     Case S_I_Page Of
  477.       1 : Begin                        { uniform load type }
  478.             ShowUniformLoading;
  479.             Show_X1_X2_DimensionLine;
  480.             ShowLoadWidthIdentifier;
  481.           End;                         { uniform load type }
  482.       2 : Begin                        { point load type }
  483.             ShowPointLoading;
  484.             Show_X_DimensionLine;
  485.           End;                         { point load type }
  486.       3 : Begin                        { prismatic load type }
  487.             ShowPrismaticLoading;
  488.             Show_X1_X2_DimensionLine;
  489.             ShowLoadWidthIdentifier;
  490.           End;                         { prismatic load type }
  491.       4 : Begin                        { applied moment type }
  492.             ShowAppliedMoment;
  493.             Show_X_DimensionLine;
  494.           End;                         { applied moment type }
  495.     End; { Case S_I_Page }
  496.     ShowLoadTypeIdentifier;
  497.     Window(1,1,80,25);                 { reset active window }
  498.   End;    { ShowBeamLoading }
  499.  
  500.  
  501.  
  502. Begin   { DisplayBeamLoadModule }
  503.   InitBeamLoadDisplay;                 { initialize DisplayBeamLoadModule }
  504.   RemoveBeamLoading;                   { remove previous beam loading }
  505.   ShowBeamLoading;                     { display present beam loading }
  506. End;    { DisplayBeamLoadModule }